using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.IO;
using System.Xml.Serialization;


using CreamX.Framework.Game.GameEngine;

namespace CreamX.Framework.Game
{
    //public class CreamXTileSet
    //{
    //    private CreamXSceneData _data;
    //    private Rectangle TileRect;
    //    private Vector2 ScreenSize;
    //    private string[] MainLayer = { };
    //    private int numTiles = 0;
    //    private int DataType;
    //    private int TileID = 0;
    //    private string tileData;
    //    private CreamXEngine.QuadTree.QuadTree<CreamXObject> _quadTree;

    //    public CreamXTileSet()
    //    {
    //    }
    //    private bool ContainsPoint(CreamXObject obj, Vector2 point)
    //    {
    //        Vector2 pnt = point - new Vector2(pathFindingGrid.TileDisplaySize.X / 2,
    //            pathFindingGrid.TileDisplaySize.Y / 2);
    //        BoundingBox __s = new BoundingBox(new Vector3(pnt, 0),
    //            new Vector3(pnt.X + pathFindingGrid.TileDisplaySize.X, pnt.Y + pathFindingGrid.TileDisplaySize.Y, 0));
    //        Vector3 __v = new Vector3(obj.Position - new Vector2(obj.DisplayWidth / 2, obj.DisplayHeight / 2), 0);
    //        BoundingBox __s1 = new BoundingBox(__v,
    //            new Vector3(__v.X + obj.DisplayWidth, __v.Y + obj.DisplayHeight, 0));

    //        return __s.Intersects(__s1);
    //    }

    //    int GetTileY(CreamXObject obj)
    //    {
    //        return (int)(obj.Position.Y / 
    //            CreamXGameEngine.Instance.SceneManager.CurrentScene.TileSets[0].TotalScreenSize.Y);
    //    }
    //    int GetTileX(CreamXObject obj)
    //    {
    //        return (int)(obj.Position.X / CreamXGameEngine.Instance.SceneManager.CurrentScene.TileSets[0].TotalScreenSize.X);
    //    }
        
    //    private GraphicsDevice GraphicsDevice
    //    {
    //        get { return CreamXGame.Instance.graphics.GraphicsDevice; }
    //    }

    //    public void Update(float gameTime)
    //    {
            
    //    }

    //    public Vector2 TotalScreenSize
    //    {
    //        get { return new Vector2(TileDisplaySize.X * TilesX, TileDisplaySize.Y * TilesY); }
    //    }

    //    public void Draw(SpriteBatch _batch, float gametime)
    //    {
    //        DrawTileSet(_batch);
    //    }

    //    public void StartGame()
    //    {
    //        ParseLevel();
    //        CreateLevel();
    //        //InitTiles();
    //    }

    //    public void CreateLevel()
    //    {
    //        Setup();
    //    }

    //    public void ParseLevel()
    //    {
    //        numTiles = Convert.ToInt32(TilesX * TilesY);
    //        string[] lines = tileData.Replace('\r',' ').Split('\n');
    //        int i = 0;
    //        string strLine = "";

    //        while (i < lines.Length) 
    //        {
    //            strLine = lines[i];
    //            strLine = strLine.Replace('\t', ' ').Trim();
    //            if (strLine.Trim() != string.Empty)
    //            {
    //                if (strLine != null && strLine != "" && !strLine.StartsWith("/"))
    //                {
    //                    if (strLine.ToLower() == "[mainlayer]")
    //                    {
    //                        DataType = 0;
    //                        TileID = 0;
    //                        MainLayer = new string[numTiles];
    //                    }
    //                    else if (strLine.ToLower() == "[decolayer]")
    //                    {
    //                        DataType = 1;
    //                        TileID = 0;
    //                    }
    //                    else if (strLine.ToLower() == "[levelinfo]")
    //                        DataType = 2;
    //                    else
    //                        BuildLevelArray(strLine);
    //                }
    //            }
    //            i++;
    //        }
    //    }

    //    public void BuildLevelArray(string strData)
    //    {
    //        string[] strSplit;
    //        if (DataType == 2)
    //        {
    //            strData = strData.ToLower();
    //            strData = strData.Trim();
    //            strSplit = strData.Split('=');
    //        }
    //        else
    //        {
    //            strSplit = strData.Split(',');
    //            foreach (string thisString in strSplit)
    //            {
    //                if (thisString != null)
    //                {
    //                    if (TileID < numTiles)
    //                    {
    //                        switch (DataType)
    //                        {
    //                            case 0:
    //                                switch (thisString)
    //                                {
    //                                    default:
    //                                        MainLayer[TileID] = thisString;
    //                                        break;
    //                                }
    //                                break;

    //                        }
    //                    }
    //                    TileID++;
    //                }
    //            }
    //        }
    //        Array.Clear(strSplit, 0, strSplit.Length);
    //    }

    //    internal void SetTileData(string p)
    //    {
    //        tileData = p;
    //    }
        
    //    public void Setup()
    //    {
    //        Tile = new Tile[MainLayer.Length];
    //        ScreenSize.X = CurrentScene.Camera.Size.X;
    //        ScreenSize.Y = CurrentScene.Camera.Size.Y;
    //        TileRect = new Rectangle(0, 0, TileCutSizeX, TileCutSizeY);

    //        SetupTiles();

    //        _quadTree = new CreamXEngine.QuadTree.QuadTree<CreamXObject>(
    //            new CreamXEngine.QuadTree.FRect(new Vector2(0, 0), 
    //            new Vector2(TotalScreenSize.X, TotalScreenSize.Y)), 10);

    //        //Array.Clear(LevelTiles, 0, LevelTiles.Length);
    //    }

    //    public void SetupTiles() 
    //    {
    //        int iTile = 0;
    //        int currentTile = 0;

    //        string[] LevelTiles = MainLayer;
    //        for (int k = 0; k < TilesY; k++)
    //        {
    //            for (int j = 0; j < TilesX; j++)
    //            {
    //                if (currentTile < LevelTiles.Length)
    //                {
    //                    if (LevelTiles[currentTile] != null)
    //                    {
    //                        if (LevelTiles[currentTile].Trim() != "" )
    //                        {
    //                            Tile[iTile] = new Tile(LevelTiles[currentTile], 
    //                                TileDisplaySize.X, TileDisplaySize.Y, 
    //                                TileRect.Width, TileRect.Height);
    //                            Tile[iTile].Origin.X = j * TileDisplaySize.X;
    //                            if (Tile[iTile].Flipped)
    //                                Tile[iTile].Origin.X += TileDisplaySize.X;
    //                            Tile[iTile].Origin.Y = k * TileDisplaySize.Y;
    //                            Tile[iTile].Location.X = Convert.ToInt32(Tile[iTile].Origin.X);
    //                            Tile[iTile].Location.Y = Convert.ToInt32(Tile[iTile].Origin.Y);
    //                            Tile[iTile].Visible = true;
    //                            Tile[iTile].SetType(Material.Texture.Width / TileCutSizeX, 
    //                                Material.Texture.Height/ TileCutSizeY, TileCutSizeX);
    //                            iTile++;
    //                        }
    //                    }
    //                    currentTile++;
    //                }
    //            }
    //        }

    //        Array.Clear(LevelTiles, 0, LevelTiles.Length);
    //    }

    //    public void InitTiles(int tilesX, int tilesY, List<uint> ignore)
    //    {
    //        pathFindingGrid = new PathFindindGrid();
    //        pathFindingGrid._ignoreList = ignore;
    //        pathFindingGrid.Owner = this;
    //        pathFindingGrid.TilesX = tilesX;
    //        pathFindingGrid.TilesY = tilesY;
    //        pathFindingGrid.TileDisplaySize = new Vector2(this.TotalScreenSize.X / tilesX, TotalScreenSize.Y / tilesY);
    //        //pathFindingGrid.TileDisplaySize = TileDisplaySize;
    //        //
    //        // Create and initialize cleared tile array.
    //        //
    //        pathFindingGrid.clear = new bool[pathFindingGrid.TilesX, pathFindingGrid.TilesY];
    //        for (int y = 0; y < pathFindingGrid.TilesY; y++)
    //        {
    //            for (int x = 0; x < pathFindingGrid.TilesX; x++)
    //            {
    //                pathFindingGrid.clear[x, y] = true;
    //            }
    //        }

    //        //
    //        // Create array of Sprites representing fixed map objects.
    //        //
    //        pathFindingGrid.tile = new CreamXObject[pathFindingGrid.TilesX, pathFindingGrid.TilesY];



    //        foreach (CreamXObject __o in CreamXGameEngine.Instance.SceneManager.CurrentScene.Objects)
    //        {
    //            if (!__o.Template)
    //            {
    //                if (!__o.CheckType(pathFindingGrid._ignoreList))
    //                {
    //                    //
    //                    // Mark tiles in use by object.
    //                    //
    //                    int objectWidthInTiles = (int)(__o.DisplayWidth / pathFindingGrid.TileDisplaySize.X) / 2;
    //                    int objectHeightInTiles = (int)(__o.DisplayHeight / pathFindingGrid.TileDisplaySize.Y) / 2;

    //                    int topTile = Math.Max(pathFindingGrid.GetTile(__o.Position).Y - objectHeightInTiles, 0);
    //                    int bottomTile = Math.Min(pathFindingGrid.GetTile(__o.Position).Y + objectHeightInTiles, pathFindingGrid.TilesX - 1);

    //                    int leftTile = Math.Max(pathFindingGrid.GetTile(__o.Position).X - objectWidthInTiles, 0);
    //                    int rightTile = Math.Min(pathFindingGrid.GetTile(__o.Position).X + objectWidthInTiles, pathFindingGrid.TilesY - 1);

    //                    //for (int y = topTile; y < bottomTile + 1; y++)
    //                    //{
    //                    //    for (int x = leftTile; x < rightTile + 1; x++)
    //                    //    {
    //                    for (int y = 0; y < pathFindingGrid.TilesY; y++)
    //                    {
    //                        for (int x = 0; x < pathFindingGrid.TilesX; x++)
    //                        {
    //                            TileMapLocation __m = pathFindingGrid.GetTile(__o.Position);
    //                            //if (y == 2 && x == 2)
    //                            //                                Console.WriteLine("");
    //                            if (ContainsPoint(__o,
    //                                pathFindingGrid.GetTileCenter(new TileMapLocation(x, y))))
    //                            {

    //                                pathFindingGrid.tile[x, y] = __o;
    //                                pathFindingGrid.clear[x, y] = false;
    //                            }
    //                        }
    //                    }
    //                }
    //            }
    //        }

    //    }

    //    internal void SetQuadTree(CreamXEngine.QuadTree.QuadTree<CreamXObject> quadTree)
    //    {
    //        _quadTree = quadTree;
    //    }
        
    //    private Rectangle GetRenderRectangle(Rectangle rect, float scale)
    //    {
    //        return new Rectangle(rect.X, rect.Y, (int)(rect.Width * scale), (int)(rect.Height * scale));
    //    }
        
    //    public void DrawTileSet( SpriteBatch spriteBatch)
    //    {
    //        if (Tile == null)
    //            return;
    //        for (int i = 0; i < Tile.Length; i++)
    //        {
    //            if (Tile[i].Visible)
    //            {
    //                Vector2 __origin = TileDisplaySize / 2;
    //                Vector2 __renderPos = CurrentScene.Camera.GetRenderPosition(Tile[i].Location + __origin);
    //                float sclae = CurrentScene.Camera.Zoom;
    //                if (IsInScreen(__renderPos,
    //                    new Vector2(TileDisplaySize.X * sclae, TileDisplaySize.Y* sclae)) == true)
    //                {
    //                    if (Tile[i].Flipped)
    //                    {
    //                        spriteBatch.Draw(Material.Texture, __renderPos, GetRenderRectangle(Tile[i].TileRectangle, sclae),
    //                            Color.White, 0f, new Vector2(0, 0), 1f,
    //                            SpriteEffects.FlipHorizontally, 0f);
    //                    }
    //                    else
    //                    {
                            
    //                        Rectangle __rect = new Rectangle((int)__renderPos.X , (int)__renderPos.Y,
    //                            (int)(TileDisplaySize.X* sclae), (int)(TileDisplaySize.Y * sclae));
                            
    //                        spriteBatch.Draw(Material.Texture, __renderPos,
    //                            Tile[i].TileRectangle,
    //                            Color.White, Tile[i].Rotation, TileDisplaySize/2, sclae, SpriteEffects.None, 0f);
    //                    }
    //                   // CreamXEngine.Text.TextEngine.Instance.DrawText(spriteBatch, i.ToString(),"ArialSmall", __renderPos, Color.White);
    //                }
    //            }
    //        }
    //    }
       
    //    public bool IsInScreen(Vector2 ObjectLocation, Vector2 ObjectSize)
    //    {
    //        if (ObjectLocation.X + (ObjectSize.X/2) >= 0 &&
    //                ObjectLocation.X-(ObjectSize.X / 2) <= ScreenSize.X)
    //        {
    //            if (ObjectLocation.Y + (ObjectSize.Y/ 2) >= 0 &&
    //                ObjectLocation.Y - (ObjectSize.Y / 2) <= ScreenSize.Y)
    //            {
    //                return true;
    //            }
    //        }
    //        return false;
    //    }

    //    [XmlIgnore()]
    //    public CreamXEngine.QuadTree.QuadTree<CreamXObject> QuadTree
    //    {
    //        get { return _quadTree; }
    //    }

    //    [XmlIgnore()]
    //    public CreamXSceneData CurrentScene
    //    {
    //        get { return _data; }
    //        set { _data = value; }
    //    }
    //    public int TilesX;
    //    public int TilesY;
    //    public int TileCutSizeX;
    //    public int TileCutSizeY;
    //    public CreamXMaterialBase Material;
    //    public Tile[] Tile;
    //    public Vector2 TileDisplaySize;

    //    [XmlIgnore()]
        
    //    public string TileData
    //    {
    //        get { return tileData; }
    //    }

    //    [XmlIgnore()]
    //    public bool QuadTreeEnabled
    //    {
    //        get { return _quadTree != null; }
    //    }
    //    [XmlIgnore()]
    //    public PathFindindGrid pathFindingGrid;

    //}

}
